// 输入处理器
export class InputHandler {
    constructor(gameEngine) {
        this.gameEngine = gameEngine;
        this.selectedCell = null;
        this.isProcessing = false;
        this.clickTimeout = null;
        this.lastClickTime = 0;
    }

    // 绑定所有输入事件
    bindEvents() {
        const renderer = this.gameEngine.renderer;
        
        // 绑定单元格点击事件
        renderer.addCellClickListener((position, element) => {
            this.handleCellClick(position, element);
        });

        // 绑定触摸事件
        renderer.addTouchListener((position, element) => {
            this.handleCellTouch(position, element);
        });

        // 绑定重新开始按钮
        renderer.bindRestartButton(() => {
            this.gameEngine.reset();
        });

        // 绑定继续按钮
        renderer.bindContinueButton(() => {
            this.gameEngine.resume();
        });

        console.log('输入事件绑定完成');
    }

    // 处理单元格点击事件（带防抖）
    handleCellClick(position, element) {
        // 防抖处理
        if (this.clickTimeout) {
            clearTimeout(this.clickTimeout);
        }

        this.clickTimeout = setTimeout(() => {
            this.processClick(position, element);
        }, 50);
    }

    // 实际处理点击的方法
    processClick(position, element) {
        console.log(`点击单元格 (${position.x}, ${position.y}), isProcessing=${this.isProcessing}`);
        
        // 防止在处理过程中重复点击
        if (this.isProcessing) {
            console.log('正在处理中，忽略点击');
            return;
        }

        // 检查游戏状态
        if (!this.gameEngine.canInteract()) {
            console.log('游戏无法交互，忽略点击');
            return;
        }

        const { x, y } = position;
        
        // 如果没有选中的单元格，选中当前单元格
        if (!this.selectedCell) {
            this.selectCell(x, y);
        } else {
            // 如果点击的是已选中的单元格，取消选择
            if (this.selectedCell.x === x && this.selectedCell.y === y) {
                this.deselectCell();
            } else {
                // 尝试交换单元格
                this.attemptSwap(this.selectedCell, { x, y });
            }
        }
    }

    // 处理触摸事件
    handleCellTouch(position, element) {
        // 触摸事件与点击事件处理逻辑相同
        this.handleCellClick(position, element);
    }

    // 选中单元格
    selectCell(x, y) {
        const cell = this.gameEngine.gameBoard.getCell(x, y);
        
        if (!cell || cell.type < 0) {
            return; // 不能选中空单元格
        }

        // 清除之前的选择
        this.deselectCell();

        // 选中新单元格
        this.selectedCell = { x, y };
        this.gameEngine.renderer.highlightCell(x, y);

        console.log(`选中单元格 (${x}, ${y})`);
    }

    // 取消选中单元格
    deselectCell() {
        if (this.selectedCell) {
            this.gameEngine.renderer.removeHighlightFromCell(this.selectedCell.x, this.selectedCell.y);
            this.selectedCell = null;
            console.log('取消选择');
        }
    }

    // 尝试交换单元格
    async attemptSwap(pos1, pos2) {
        this.isProcessing = true;

        try {
            // 检查是否相邻
            if (!this.isValidSelection(pos1, pos2)) {
                // 如果不相邻，选中新的单元格
                this.selectCell(pos2.x, pos2.y);
                this.isProcessing = false;
                return;
            }

            // 检查交换是否有效（会产生匹配）
            if (!this.gameEngine.gameBoard.isValidSwap(pos1, pos2)) {
                // 无效交换，显示提示并保持选择
                this.gameEngine.renderer.showStatusMessage('无效的交换！', 1000);
                this.isProcessing = false;
                return;
            }

            // 执行交换
            console.log(`交换单元格 (${pos1.x}, ${pos1.y}) 和 (${pos2.x}, ${pos2.y})`);
            
            // 清除选择状态
            this.deselectCell();
            
            // 通知游戏引擎处理交换
            await this.gameEngine.handleSwap(pos1, pos2);

        } catch (error) {
            console.error('交换操作失败:', error);
        } finally {
            this.isProcessing = false;
        }
    }

    // 验证选择是否有效
    isValidSelection(pos1, pos2) {
        // 检查坐标是否有效
        if (!this.gameEngine.gameBoard.isValidPosition(pos1.x, pos1.y) ||
            !this.gameEngine.gameBoard.isValidPosition(pos2.x, pos2.y)) {
            return false;
        }

        // 检查是否相邻
        return this.gameEngine.gameBoard.areAdjacent(pos1, pos2);
    }

    // 获取单元格位置（从事件）
    getCellPosition(event) {
        const element = event.target.closest('.ghost-cell');
        if (!element) return null;

        return this.gameEngine.renderer.getCellPosition(element);
    }

    // 处理键盘事件（可选功能）
    handleKeyPress(event) {
        switch (event.key) {
            case 'Escape':
                this.deselectCell();
                break;
            case 'r':
            case 'R':
                if (event.ctrlKey || event.metaKey) {
                    event.preventDefault();
                    this.gameEngine.reset();
                }
                break;
            case ' ':
                event.preventDefault();
                if (this.gameEngine.isPaused()) {
                    this.gameEngine.resume();
                } else {
                    this.gameEngine.pause();
                }
                break;
        }
    }

    // 绑定键盘事件
    bindKeyboardEvents() {
        document.addEventListener('keydown', (event) => {
            this.handleKeyPress(event);
        });
    }

    // 启用/禁用输入
    setEnabled(enabled) {
        this.isProcessing = !enabled;
        
        if (!enabled) {
            this.deselectCell();
        }
    }

    // 获取当前选中的单元格
    getSelectedCell() {
        return this.selectedCell;
    }

    // 清除所有状态
    reset() {
        this.deselectCell();
        this.isProcessing = false;
    }
}